/*
 * backward.hpp
 * Copyright 2013 Google Inc. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef H_6B9572DA_A64B_49E6_B234_051480991C89
#define H_6B9572DA_A64B_49E6_B234_051480991C89

#ifndef __cplusplus
#error "It's not going to compile without a C++ compiler..."
#endif

#if defined(BACKWARD_CXX11)
#elif defined(BACKWARD_CXX98)
#else
#if __cplusplus >= 201103L
#define BACKWARD_CXX11
#define BACKWARD_ATLEAST_CXX11
#define BACKWARD_ATLEAST_CXX98
#else
#define BACKWARD_CXX98
#define BACKWARD_ATLEAST_CXX98
#endif
#endif

// You can define one of the following (or leave it to the auto-detection):
//
// #define BACKWARD_SYSTEM_LINUX
//	- specialization for linux
//
// #define BACKWARD_SYSTEM_UNKNOWN
//	- placebo implementation, does nothing.
//
#if defined(BACKWARD_SYSTEM_LINUX)
#elif defined(BACKWARD_SYSTEM_UNKNOWN)
#else
#if defined(__linux)
#define BACKWARD_SYSTEM_LINUX
#else
#define BACKWARD_SYSTEM_UNKNOWN
#endif
#endif

#include <fstream>
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <string>
#include <new>
#include <iomanip>
#include <vector>

#if defined(BACKWARD_SYSTEM_LINUX)

// On linux, backtrace can back-trace or "walk" the stack using the following
// libraries:
//
// #define BACKWARD_HAS_UNWIND 1
//  - unwind comes from libgcc, but I saw an equivalent inside clang itself.
//  - with unwind, the stacktrace is as accurate as it can possibly be, since
//  this is used by the C++ runtine in gcc/clang for stack unwinding on
//  exception.
//  - normally libgcc is already linked to your program by default.
//
// #define BACKWARD_HAS_BACKTRACE == 1
//  - backtrace seems to be a little bit more portable than libunwind, but on
//  linux, it uses unwind anyway, but abstract away a tiny information that is
//  sadly really important in order to get perfectly accurate stack traces.
//  - backtrace is part of the (e)glib library.
//
// The default is:
// #define BACKWARD_HAS_UNWIND == 1
//
// Note that only one of the define should be set to 1 at a time.
//
#if BACKWARD_HAS_UNWIND == 1
#elif BACKWARD_HAS_BACKTRACE == 1
#else
#undef BACKWARD_HAS_UNWIND
#define BACKWARD_HAS_UNWIND 1
#undef BACKWARD_HAS_BACKTRACE
#define BACKWARD_HAS_BACKTRACE 0
#endif

// On linux, backward can extract detailed information about a stack trace
// using one of the following libraries:
//
// #define BACKWARD_HAS_DW 1
//  - libdw gives you the most juicy details out of your stack traces:
//    - object filename
//    - function name
//    - source filename
//	  - line and column numbers
//	  - source code snippet (assuming the file is accessible)
//	  - variables name and values (if not optimized out)
//  - You need to link with the lib "dw":
//    - apt-get install libdw-dev
//    - g++/clang++ -ldw ...
//
// #define BACKWARD_HAS_BFD 1
//  - With libbfd, you get a fair amount of details:
//    - object filename
//    - function name
//    - source filename
//	  - line numbers
//	  - source code snippet (assuming the file is accessible)
//  - You need to link with the lib "bfd":
//    - apt-get install binutils-dev
//    - g++/clang++ -lbfd ...
//
// #define BACKWARD_HAS_BACKTRACE_SYMBOL 1
//  - backtrace provides minimal details for a stack trace:
//    - object filename
//    - function name
//  - backtrace is part of the (e)glib library.
//
// The default is:
// #define BACKWARD_HAS_BACKTRACE_SYMBOL == 1
//
// Note that only one of the define should be set to 1 at a time.
//
#if BACKWARD_HAS_DW == 1
#elif BACKWARD_HAS_BFD == 1
#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1
#else
#undef BACKWARD_HAS_DW
#define BACKWARD_HAS_DW 0
#undef BACKWARD_HAS_BFD
#define BACKWARD_HAS_BFD 0
#undef BACKWARD_HAS_BACKTRACE_SYMBOL
#define BACKWARD_HAS_BACKTRACE_SYMBOL 1
#endif

#if BACKWARD_HAS_UNWIND == 1

#include <unwind.h>
// while gcc's unwind.h defines something like that:
//  extern _Unwind_Ptr _Unwind_GetIP (struct _Unwind_Context *);
//  extern _Unwind_Ptr _Unwind_GetIPInfo (struct _Unwind_Context *, int *);
//
// clang's unwind.h defines something like this:
//  uintptr_t _Unwind_GetIP(struct _Unwind_Context* __context);
//
// Even if the _Unwind_GetIPInfo can be linked to, it is not declared, worse we
// cannot just redeclare it because clang's unwind.h doesn't define _Unwind_Ptr
// anyway.
//
// Luckily we can play on the fact that the guard macros have a different name:
#ifdef __CLANG_UNWIND_H
// In fact, this function still comes from libgcc (on my different linux boxes,
// clang links against libgcc).
#include <inttypes.h>
extern "C" uintptr_t _Unwind_GetIPInfo(_Unwind_Context *, int *);
#endif

#endif

#include <cxxabi.h>
#include <fcntl.h>
#include <link.h>
#include <sys/stat.h>
#include <syscall.h>
#include <unistd.h>
#include <signal.h>

#if BACKWARD_HAS_BFD == 1
//              NOTE: defining PACKAGE{,_VERSION} is required before including
//                    bfd.h on some platforms, see also:
//                    https://sourceware.org/bugzilla/show_bug.cgi?id=14243
#ifndef PACKAGE
#define PACKAGE
#endif
#ifndef PACKAGE_VERSION
#define PACKAGE_VERSION
#endif
#include <bfd.h>
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#include <dlfcn.h>
#undef _GNU_SOURCE
#else
#include <dlfcn.h>
#endif
#endif

#if BACKWARD_HAS_DW == 1
#include <elfutils/libdw.h>
#include <elfutils/libdwfl.h>
#include <dwarf.h>
#endif

#if (BACKWARD_HAS_BACKTRACE == 1) || (BACKWARD_HAS_BACKTRACE_SYMBOL == 1)
// then we shall rely on backtrace
#include <execinfo.h>
#endif

#endif // defined(BACKWARD_SYSTEM_LINUX)

#ifdef BACKWARD_ATLEAST_CXX11
#include <unordered_map>
#include <utility> // for std::swap
namespace backward
{
	namespace details
	{
		template <typename K, typename V>
		struct hashtable
		{
			typedef std::unordered_map<K, V> type;
		};
		using std::move;
	} // namespace details
} // namespace backward
#else // NOT BACKWARD_ATLEAST_CXX11
#include <map>
namespace backward
{
	namespace details
	{
		template <typename K, typename V>
		struct hashtable
		{
			typedef std::map<K, V> type;
		};
		template <typename T>
		const T &move(const T &v) { return v; }
		template <typename T>
		T &move(T &v) { return v; }
	} // namespace details
} // namespace backward
#endif // BACKWARD_ATLEAST_CXX11

namespace backward
{

	namespace system_tag
	{
		struct linux_tag; // seems that I cannot call that "linux" because the name
		// is already defined... so I am adding _tag everywhere.
		struct unknown_tag;

#if defined(BACKWARD_SYSTEM_LINUX)
		typedef linux_tag current_tag;
#elif defined(BACKWARD_SYSTEM_UNKNOWN)
		typedef unknown_tag current_tag;
#else
#error "May I please get my system defines?"
#endif
	} // namespace system_tag

	namespace trace_resolver_tag
	{
#ifdef BACKWARD_SYSTEM_LINUX
		struct libdw;
		struct libbfd;
		struct backtrace_symbol;

#if BACKWARD_HAS_DW == 1
		typedef libdw current;
#elif BACKWARD_HAS_BFD == 1
		typedef libbfd current;
#elif BACKWARD_HAS_BACKTRACE_SYMBOL == 1
		typedef backtrace_symbol current;
#else
#error "You shall not pass, until you know what you want."
#endif
#endif // BACKWARD_SYSTEM_LINUX
	}  // namespace trace_resolver_tag

	namespace details
	{

		template <typename T>
		struct rm_ptr
		{
			typedef T type;
		};

		template <typename T>
		struct rm_ptr<T *>
		{
			typedef T type;
		};

		template <typename T>
		struct rm_ptr<const T *>
		{
			typedef const T type;
		};

		template <typename R, typename T, R (*F)(T)>
		struct deleter
		{
			template <typename U>
			void operator()(U &ptr) const
			{
				(*F)(ptr);
			}
		};

		template <typename T>
		struct default_delete
		{
			void operator()(T &ptr) const
			{
				delete ptr;
			}
		};

		template <typename T, typename Deleter = deleter<void, void *, &::free>>
		class handle
		{
			struct dummy;
			T _val;
			bool _empty;

#ifdef BACKWARD_ATLEAST_CXX11
			handle(const handle &) = delete;
			handle &operator=(const handle &) = delete;
#endif

		public:
			~handle()
			{
				if (!_empty)
				{
					Deleter()(_val);
				}
			}

			explicit handle() : _val(), _empty(true) {}
			explicit handle(T val) : _val(val), _empty(false) {}

#ifdef BACKWARD_ATLEAST_CXX11
			handle(handle &&from) : _empty(true)
			{
				swap(from);
			}
			handle &operator=(handle &&from)
			{
				swap(from);
				return *this;
			}
#else
			explicit handle(const handle &from) : _empty(true)
			{
				// some sort of poor man's move semantic.
				swap(const_cast<handle &>(from));
			}
			handle &operator=(const handle &from)
			{
				// some sort of poor man's move semantic.
				swap(const_cast<handle &>(from));
				return *this;
			}
#endif

			void reset(T new_val)
			{
				handle tmp(new_val);
				swap(tmp);
			}
			operator const dummy *() const
			{
				if (_empty)
				{
					return 0;
				}
				return reinterpret_cast<const dummy *>(_val);
			}
			T get()
			{
				return _val;
			}
			T release()
			{
				_empty = true;
				return _val;
			}
			void swap(handle &b)
			{
				using std::swap;
				swap(b._val, _val);		// can throw, we are safe here.
				swap(b._empty, _empty); // should not throw: if you cannot swap two
										// bools without throwing... It's a lost cause anyway!
			}

			T operator->() { return _val; }
			const T operator->() const { return _val; }

			typedef typename rm_ptr<T>::type &ref_t;
			typedef const typename rm_ptr<T>::type &const_ref_t;
			ref_t operator*() { return *_val; }
			const_ref_t operator*() const { return *_val; }
			ref_t operator[](size_t idx) { return _val[idx]; }

			// Watch out, we've got a badass over here
			T *operator&()
			{
				_empty = false;
				return &_val;
			}
		};

		// Default demangler implementation (do nothing).
		template <typename TAG>
		struct demangler_impl
		{
			static std::string demangle(const char *funcname)
			{
				return funcname;
			}
		};

#ifdef BACKWARD_SYSTEM_LINUX

		template <>
		struct demangler_impl<system_tag::current_tag>
		{
			demangler_impl() : _demangle_buffer_length(0) {}

			std::string demangle(const char *funcname)
			{
				using namespace details;
				_demangle_buffer.reset(
					abi::__cxa_demangle(funcname, _demangle_buffer.release(),
										&_demangle_buffer_length, 0));
				if (_demangle_buffer)
				{
					return _demangle_buffer.get();
				}
				return funcname;
			}

		private:
			details::handle<char *> _demangle_buffer;
			size_t _demangle_buffer_length;
		};

#endif // BACKWARD_SYSTEM_LINUX

		struct demangler : public demangler_impl<system_tag::current_tag>
		{
		};

	} // namespace details

	/*************** A TRACE ***************/

	struct Trace
	{
		void *addr;
		unsigned idx;

		Trace() : addr(0), idx(0) {}

		explicit Trace(void *addr, size_t idx) : addr(addr), idx(idx) {}
	};

	struct ResolvedTrace : public Trace
	{

		struct SourceLoc
		{
			std::string function;
			std::string filename;
			unsigned line;
			unsigned col;

			SourceLoc() : line(0), col(0) {}

			bool operator==(const SourceLoc &b) const
			{
				return function == b.function && filename == b.filename && line == b.line && col == b.col;
			}

			bool operator!=(const SourceLoc &b) const
			{
				return !(*this == b);
			}
		};

		// In which binary object this trace is located.
		std::string object_filename;

		// The function in the object that contain the trace. This is not the same
		// as source.function which can be an function inlined in object_function.
		std::string object_function;

		// The source location of this trace. It is possible for filename to be
		// empty and for line/col to be invalid (value 0) if this information
		// couldn't be deduced, for example if there is no debug information in the
		// binary object.
		SourceLoc source;

		// An optionals list of "inliners". All the successive sources location
		// from where the source location of the trace (the attribute right above)
		// is inlined. It is especially useful when you compiled with optimization.
		typedef std::vector<SourceLoc> source_locs_t;
		source_locs_t inliners;

		ResolvedTrace() : Trace() {}
		ResolvedTrace(const Trace &mini_trace) : Trace(mini_trace) {}
	};

	/*************** STACK TRACE ***************/

	// default implemention.
	template <typename TAG>
	class StackTraceImpl
	{
	public:
		size_t size() const { return 0; }
		Trace operator[](size_t) { return Trace(); }
		size_t load_here(size_t = 0) { return 0; }
		size_t load_from(void *, size_t = 0) { return 0; }
		unsigned thread_id() const { return 0; }
	};

#ifdef BACKWARD_SYSTEM_LINUX

	class StackTraceLinuxImplBase
	{
	public:
		StackTraceLinuxImplBase() : _thread_id(0), _skip(0) {}

		unsigned thread_id() const
		{
			return _thread_id;
		}

	protected:
		void load_thread_info()
		{
			_thread_id = syscall(SYS_gettid);
			if (_thread_id == (size_t)getpid())
			{
				// If the thread is the main one, let's hide that.
				// I like to keep little secret sometimes.
				_thread_id = 0;
			}
		}

		void skip_n_firsts(size_t n) { _skip = n; }
		size_t skip_n_firsts() const { return _skip; }

	private:
		size_t _thread_id;
		size_t _skip;
	};

	class StackTraceLinuxImplHolder : public StackTraceLinuxImplBase
	{
	public:
		size_t size() const
		{
			return _stacktrace.size() ? _stacktrace.size() - skip_n_firsts() : 0;
		}
		Trace operator[](size_t idx)
		{
			if (idx >= size())
			{
				return Trace();
			}
			return Trace(_stacktrace[idx + skip_n_firsts()], idx);
		}
		void **begin()
		{
			if (size())
			{
				return &_stacktrace[skip_n_firsts()];
			}
			return 0;
		}

	protected:
		std::vector<void *> _stacktrace;
	};

#if BACKWARD_HAS_UNWIND == 1

	namespace details
	{

		template <typename F>
		class Unwinder
		{
		public:
			size_t operator()(F &f, size_t depth)
			{
				_f = &f;
				_index = -1;
				_depth = depth;
				_Unwind_Backtrace(&this->backtrace_trampoline, this);
				return _index;
			}

		private:
			F *_f;
			ssize_t _index;
			size_t _depth;

			static _Unwind_Reason_Code backtrace_trampoline(
				_Unwind_Context *ctx, void *self)
			{
				return ((Unwinder *)self)->backtrace(ctx);
			}

			_Unwind_Reason_Code backtrace(_Unwind_Context *ctx)
			{
				if (_index >= 0 && static_cast<size_t>(_index) >= _depth)
					return _URC_END_OF_STACK;

				int ip_before_instruction = 0;
				uintptr_t ip = _Unwind_GetIPInfo(ctx, &ip_before_instruction);

				if (!ip_before_instruction)
				{
					ip -= 1;
				}

				if (_index >= 0)
				{ // ignore first frame.
					(*_f)(_index, (void *)ip);
				}
				_index += 1;
				return _URC_NO_REASON;
			}
		};

		template <typename F>
		size_t unwind(F f, size_t depth)
		{
			Unwinder<F> unwinder;
			return unwinder(f, depth);
		}

	} // namespace details

	template <>
	class StackTraceImpl<system_tag::linux_tag> : public StackTraceLinuxImplHolder
	{
	public:
		__attribute__((noinline)) // TODO use some macro
		size_t
		load_here(size_t depth = 32)
		{
			load_thread_info();
			if (depth == 0)
			{
				return 0;
			}
			_stacktrace.resize(depth);
			size_t trace_cnt = details::unwind(callback(*this), depth);
			_stacktrace.resize(trace_cnt);
			skip_n_firsts(0);
			return size();
		}
		size_t load_from(void *addr, size_t depth = 32)
		{
			load_here(depth + 8);

			for (size_t i = 0; i < _stacktrace.size(); ++i)
			{
				if (_stacktrace[i] == addr)
				{
					skip_n_firsts(i);
					break;
				}
			}

			_stacktrace.resize(std::min(_stacktrace.size(),
										skip_n_firsts() + depth));
			return size();
		}

	private:
		struct callback
		{
			StackTraceImpl &self;
			callback(StackTraceImpl &self) : self(self) {}

			void operator()(size_t idx, void *addr)
			{
				self._stacktrace[idx] = addr;
			}
		};
	};

#else // BACKWARD_HAS_UNWIND == 0

	template <>
	class StackTraceImpl<system_tag::linux_tag> : public StackTraceLinuxImplHolder
	{
	public:
		__attribute__((noinline)) // TODO use some macro
		size_t
		load_here(size_t depth = 32)
		{
			load_thread_info();
			if (depth == 0)
			{
				return 0;
			}
			_stacktrace.resize(depth + 1);
			size_t trace_cnt = backtrace(&_stacktrace[0], _stacktrace.size());
			_stacktrace.resize(trace_cnt);
			skip_n_firsts(1);
			return size();
		}

		size_t load_from(void *addr, size_t depth = 32)
		{
			load_here(depth + 8);

			for (size_t i = 0; i < _stacktrace.size(); ++i)
			{
				if (_stacktrace[i] == addr)
				{
					skip_n_firsts(i);
					_stacktrace[i] = (void *)((uintptr_t)_stacktrace[i] + 1);
					break;
				}
			}

			_stacktrace.resize(std::min(_stacktrace.size(),
										skip_n_firsts() + depth));
			return size();
		}
	};

#endif // BACKWARD_HAS_UNWIND
#endif // BACKWARD_SYSTEM_LINUX

	class StackTrace : public StackTraceImpl<system_tag::current_tag>
	{
	};

	/*************** TRACE RESOLVER ***************/

	template <typename TAG>
	class TraceResolverImpl;

#ifdef BACKWARD_SYSTEM_UNKNOWN

	template <>
	class TraceResolverImpl<system_tag::unknown_tag>
	{
	public:
		template <class ST>
		void load_stacktrace(ST &) {}
		ResolvedTrace resolve(ResolvedTrace t)
		{
			return t;
		}
	};

#endif

#ifdef BACKWARD_SYSTEM_LINUX

	class TraceResolverLinuxImplBase
	{
	protected:
		std::string demangle(const char *funcname)
		{
			return _demangler.demangle(funcname);
		}

	private:
		details::demangler _demangler;
	};

	template <typename STACKTRACE_TAG>
	class TraceResolverLinuxImpl;

#if BACKWARD_HAS_BACKTRACE_SYMBOL == 1

	template <>
	class TraceResolverLinuxImpl<trace_resolver_tag::backtrace_symbol> : public TraceResolverLinuxImplBase
	{
	public:
		template <class ST>
		void load_stacktrace(ST &st)
		{
			using namespace details;
			if (st.size() == 0)
			{
				return;
			}
			_symbols.reset(
				backtrace_symbols(st.begin(), st.size()));
		}

		ResolvedTrace resolve(ResolvedTrace trace)
		{
			char *filename = _symbols[trace.idx];
			char *funcname = filename;
			while (*funcname && *funcname != '(')
			{
				funcname += 1;
			}
			trace.object_filename.assign(filename, funcname++);
			char *funcname_end = funcname;
			while (*funcname_end && *funcname_end != ')' && *funcname_end != '+')
			{
				funcname_end += 1;
			}
			*funcname_end = '\0';
			trace.object_function = this->demangle(funcname);
			trace.source.function = trace.object_function; // we cannot do better.
			return trace;
		}

	private:
		details::handle<char **> _symbols;
	};

#endif // BACKWARD_HAS_BACKTRACE_SYMBOL == 1

#if BACKWARD_HAS_BFD == 1

	template <>
	class TraceResolverLinuxImpl<trace_resolver_tag::libbfd> : public TraceResolverLinuxImplBase
	{
	public:
		TraceResolverLinuxImpl() : _bfd_loaded(false) {}

		template <class ST>
		void load_stacktrace(ST &) {}

		ResolvedTrace resolve(ResolvedTrace trace)
		{
			Dl_info symbol_info;

			// trace.addr is a virtual address in memory pointing to some code.
			// Let's try to find from which loaded object it comes from.
			// The loaded object can be yourself btw.
			if (!dladdr(trace.addr, &symbol_info))
			{
				return trace; // dat broken trace...
			}

			// Now we get in symbol_info:
			// .dli_fname:
			//		pathname of the shared object that contains the address.
			// .dli_fbase:
			//		where the object is loaded in memory.
			// .dli_sname:
			//		the name of the nearest symbol to trace.addr, we expect a
			//		function name.
			// .dli_saddr:
			//		the exact address corresponding to .dli_sname.

			if (symbol_info.dli_sname)
			{
				trace.object_function = demangle(symbol_info.dli_sname);
			}

			if (!symbol_info.dli_fname)
			{
				return trace;
			}

			trace.object_filename = symbol_info.dli_fname;
			bfd_fileobject &fobj = load_object_with_bfd(symbol_info.dli_fname);
			if (!fobj.handle)
			{
				return trace; // sad, we couldn't load the object :(
			}

			find_sym_result *details_selected; // to be filled.

			// trace.addr is the next instruction to be executed after returning
			// from the nested stack frame. In C++ this usually relate to the next
			// statement right after the function call that leaded to a new stack
			// frame. This is not usually what you want to see when printing out a
			// stacktrace...
			find_sym_result details_call_site = find_symbol_details(fobj,
																	trace.addr, symbol_info.dli_fbase);
			details_selected = &details_call_site;

#if BACKWARD_HAS_UNWIND == 0
			// ...this is why we also try to resolve the symbol that is right
			// before the return address. If we are lucky enough, we will get the
			// line of the function that was called. But if the code is optimized,
			// we might get something absolutely not related since the compiler
			// can reschedule the return address with inline functions and
			// tail-call optimisation (among other things that I don't even know
			// or cannot even dream about with my tiny limited brain).
			find_sym_result details_adjusted_call_site = find_symbol_details(fobj,
																			 (void *)(uintptr_t(trace.addr) - 1),
																			 symbol_info.dli_fbase);

			// In debug mode, we should always get the right thing(TM).
			if (details_call_site.found && details_adjusted_call_site.found)
			{
				// Ok, we assume that details_adjusted_call_site is a better estimation.
				details_selected = &details_adjusted_call_site;
				trace.addr = (void *)(uintptr_t(trace.addr) - 1);
			}

			if (details_selected == &details_call_site && details_call_site.found)
			{
				// we have to re-resolve the symbol in order to reset some
				// internal state in BFD... so we can call backtrace_inliners
				// thereafter...
				details_call_site = find_symbol_details(fobj, trace.addr,
														symbol_info.dli_fbase);
			}
#endif // BACKWARD_HAS_UNWIND

			if (details_selected->found)
			{
				if (details_selected->filename)
				{
					trace.source.filename = details_selected->filename;
				}
				trace.source.line = details_selected->line;

				if (details_selected->funcname)
				{
					// this time we get the name of the function where the code is
					// located, instead of the function were the address is
					// located. In short, if the code was inlined, we get the
					// function correspoding to the code. Else we already got in
					// trace.function.
					trace.source.function = demangle(details_selected->funcname);

					if (!symbol_info.dli_sname)
					{
						// for the case dladdr failed to find the symbol name of
						// the function, we might as well try to put something
						// here.
						trace.object_function = trace.source.function;
					}
				}

				// Maybe the source of the trace got inlined inside the function
				// (trace.source.function). Let's see if we can get all the inlined
				// calls along the way up to the initial call site.
				trace.inliners = backtrace_inliners(fobj, *details_selected);

#if 0
			if (trace.inliners.size() == 0) {
				// Maybe the trace was not inlined... or maybe it was and we
				// are lacking the debug information. Let's try to make the
				// world better and see if we can get the line number of the
				// function (trace.source.function) now.
				//
				// We will get the location of where the function start (to be
				// exact: the first instruction that really start the
				// function), not where the name of the function is defined.
				// This can be quite far away from the name of the function
				// btw.
				//
				// If the source of the function is the same as the source of
				// the trace, we cannot say if the trace was really inlined or
				// not.  However, if the filename of the source is different
				// between the function and the trace... we can declare it as
				// an inliner.  This is not 100% accurate, but better than
				// nothing.

				if (symbol_info.dli_saddr) {
					find_sym_result details = find_symbol_details(fobj,
							symbol_info.dli_saddr,
							symbol_info.dli_fbase);

					if (details.found) {
						ResolvedTrace::SourceLoc diy_inliner;
						diy_inliner.line = details.line;
						if (details.filename) {
							diy_inliner.filename = details.filename;
						}
						if (details.funcname) {
							diy_inliner.function = demangle(details.funcname);
						} else {
							diy_inliner.function = trace.source.function;
						}
						if (diy_inliner != trace.source) {
							trace.inliners.push_back(diy_inliner);
						}
					}
				}
			}
#endif
			}

			return trace;
		}

	private:
		bool _bfd_loaded;

		typedef details::handle<bfd *,
								details::deleter<bfd_boolean, bfd *, &bfd_close>>
			bfd_handle_t;

		typedef details::handle<asymbol **> bfd_symtab_t;

		struct bfd_fileobject
		{
			bfd_handle_t handle;
			bfd_vma base_addr;
			bfd_symtab_t symtab;
			bfd_symtab_t dynamic_symtab;
		};

		typedef details::hashtable<std::string, bfd_fileobject>::type
			fobj_bfd_map_t;
		fobj_bfd_map_t _fobj_bfd_map;

		bfd_fileobject &load_object_with_bfd(const std::string &filename_object)
		{
			using namespace details;

			if (!_bfd_loaded)
			{
				using namespace details;
				bfd_init();
				_bfd_loaded = true;
			}

			fobj_bfd_map_t::iterator it =
				_fobj_bfd_map.find(filename_object);
			if (it != _fobj_bfd_map.end())
			{
				return it->second;
			}

			// this new object is empty for now.
			bfd_fileobject &r = _fobj_bfd_map[filename_object];

			// we do the work temporary in this one;
			bfd_handle_t bfd_handle;

			int fd = open(filename_object.c_str(), O_RDONLY);
			bfd_handle.reset(
				bfd_fdopenr(filename_object.c_str(), "default", fd));
			if (!bfd_handle)
			{
				close(fd);
				return r;
			}

			if (!bfd_check_format(bfd_handle.get(), bfd_object))
			{
				return r; // not an object? You lose.
			}

			if ((bfd_get_file_flags(bfd_handle.get()) & HAS_SYMS) == 0)
			{
				return r; // that's what happen when you forget to compile in debug.
			}

			ssize_t symtab_storage_size =
				bfd_get_symtab_upper_bound(bfd_handle.get());

			ssize_t dyn_symtab_storage_size =
				bfd_get_dynamic_symtab_upper_bound(bfd_handle.get());

			if (symtab_storage_size <= 0 && dyn_symtab_storage_size <= 0)
			{
				return r; // weird, is the file is corrupted?
			}

			bfd_symtab_t symtab, dynamic_symtab;
			ssize_t symcount = 0, dyn_symcount = 0;

			if (symtab_storage_size > 0)
			{
				symtab.reset(
					(bfd_symbol **)malloc(symtab_storage_size));
				symcount = bfd_canonicalize_symtab(
					bfd_handle.get(), symtab.get());
			}

			if (dyn_symtab_storage_size > 0)
			{
				dynamic_symtab.reset(
					(bfd_symbol **)malloc(dyn_symtab_storage_size));
				dyn_symcount = bfd_canonicalize_dynamic_symtab(
					bfd_handle.get(), dynamic_symtab.get());
			}

			if (symcount <= 0 && dyn_symcount <= 0)
			{
				return r; // damned, that's a stripped file that you got there!
			}

			r.handle = move(bfd_handle);
			r.symtab = move(symtab);
			r.dynamic_symtab = move(dynamic_symtab);
			return r;
		}

		struct find_sym_result
		{
			bool found;
			const char *filename;
			const char *funcname;
			unsigned int line;
		};

		struct find_sym_context
		{
			TraceResolverLinuxImpl *self;
			bfd_fileobject *fobj;
			void *addr;
			void *base_addr;
			find_sym_result result;
		};

		find_sym_result find_symbol_details(bfd_fileobject &fobj, void *addr,
											void *base_addr)
		{
			find_sym_context context;
			context.self = this;
			context.fobj = &fobj;
			context.addr = addr;
			context.base_addr = base_addr;
			context.result.found = false;
			bfd_map_over_sections(fobj.handle.get(), &find_in_section_trampoline,
								  (void *)&context);
			return context.result;
		}

		static void find_in_section_trampoline(bfd *, asection *section,
											   void *data)
		{
			find_sym_context *context = static_cast<find_sym_context *>(data);
			context->self->find_in_section(
				reinterpret_cast<bfd_vma>(context->addr),
				reinterpret_cast<bfd_vma>(context->base_addr),
				*context->fobj,
				section, context->result);
		}

		void find_in_section(bfd_vma addr, bfd_vma base_addr,
							 bfd_fileobject &fobj, asection *section, find_sym_result &result)
		{
			if (result.found)
				return;

			if ((bfd_get_section_flags(fobj.handle.get(), section) & SEC_ALLOC) == 0)
				return; // a debug section is never loaded automatically.

			bfd_vma sec_addr = bfd_get_section_vma(fobj.handle.get(), section);
			bfd_size_type size = bfd_get_section_size(section);

			// are we in the boundaries of the section?
			if (addr < sec_addr || addr >= sec_addr + size)
			{
				addr -= base_addr; // oups, a relocated object, lets try again...
				if (addr < sec_addr || addr >= sec_addr + size)
				{
					return;
				}
			}

			if (!result.found && fobj.symtab)
			{
				result.found = bfd_find_nearest_line(fobj.handle.get(), section,
													 fobj.symtab.get(), addr - sec_addr, &result.filename,
													 &result.funcname, &result.line);
			}

			if (!result.found && fobj.dynamic_symtab)
			{
				result.found = bfd_find_nearest_line(fobj.handle.get(), section,
													 fobj.dynamic_symtab.get(), addr - sec_addr,
													 &result.filename, &result.funcname, &result.line);
			}
		}

		ResolvedTrace::source_locs_t backtrace_inliners(bfd_fileobject &fobj,
														find_sym_result previous_result)
		{
			// This function can be called ONLY after a SUCCESSFUL call to
			// find_symbol_details. The state is global to the bfd_handle.
			ResolvedTrace::source_locs_t results;
			while (previous_result.found)
			{
				find_sym_result result;
				result.found = bfd_find_inliner_info(fobj.handle.get(),
													 &result.filename, &result.funcname, &result.line);

				if (result.found) /* and not (
							cstrings_eq(previous_result.filename, result.filename)
							and cstrings_eq(previous_result.funcname, result.funcname)
							and result.line == previous_result.line
							)) */
				{
					ResolvedTrace::SourceLoc src_loc;
					src_loc.line = result.line;
					if (result.filename)
					{
						src_loc.filename = result.filename;
					}
					if (result.funcname)
					{
						src_loc.function = demangle(result.funcname);
					}
					results.push_back(src_loc);
				}
				previous_result = result;
			}
			return results;
		}

		bool cstrings_eq(const char *a, const char *b)
		{
			if (!a || !b)
			{
				return false;
			}
			return strcmp(a, b) == 0;
		}
	};
#endif // BACKWARD_HAS_BFD == 1

#if BACKWARD_HAS_DW == 1

	template <>
	class TraceResolverLinuxImpl<trace_resolver_tag::libdw> : public TraceResolverLinuxImplBase
	{
	public:
		TraceResolverLinuxImpl() : _dwfl_handle_initialized(false) {}

		template <class ST>
		void load_stacktrace(ST &) {}

		ResolvedTrace resolve(ResolvedTrace trace)
		{
			using namespace details;

			Dwarf_Addr trace_addr = (Dwarf_Addr)trace.addr;

			if (!_dwfl_handle_initialized)
			{
				// initialize dwfl...
				_dwfl_cb.reset(new Dwfl_Callbacks);
				_dwfl_cb->find_elf = &dwfl_linux_proc_find_elf;
				_dwfl_cb->find_debuginfo = &dwfl_standard_find_debuginfo;
				_dwfl_cb->debuginfo_path = 0;

				_dwfl_handle.reset(dwfl_begin(_dwfl_cb.get()));
				_dwfl_handle_initialized = true;

				if (!_dwfl_handle)
				{
					return trace;
				}

				// ...from the current process.
				dwfl_report_begin(_dwfl_handle.get());
				int r = dwfl_linux_proc_report(_dwfl_handle.get(), getpid());
				dwfl_report_end(_dwfl_handle.get(), NULL, NULL);
				if (r < 0)
				{
					return trace;
				}
			}

			if (!_dwfl_handle)
			{
				return trace;
			}

			// find the module (binary object) that contains the trace's address.
			// This is not using any debug information, but the addresses ranges of
			// all the currently loaded binary object.
			Dwfl_Module *mod = dwfl_addrmodule(_dwfl_handle.get(), trace_addr);
			if (mod)
			{
				// now that we found it, lets get the name of it, this will be the
				// full path to the running binary or one of the loaded library.
				const char *module_name = dwfl_module_info(mod,
														   0, 0, 0, 0, 0, 0, 0);
				if (module_name)
				{
					trace.object_filename = module_name;
				}
				// We also look after the name of the symbol, equal or before this
				// address. This is found by walking the symtab. We should get the
				// symbol corresponding to the function (mangled) containing the
				// address. If the code corresponding to the address was inlined,
				// this is the name of the out-most inliner function.
				const char *sym_name = dwfl_module_addrname(mod, trace_addr);
				if (sym_name)
				{
					trace.object_function = demangle(sym_name);
				}
			}

			// now let's get serious, and find out the source location (file and
			// line number) of the address.

			// This function will look in .debug_aranges for the address and map it
			// to the location of the compilation unit DIE in .debug_info and
			// return it.
			Dwarf_Addr mod_bias = 0;
			Dwarf_Die *cudie = dwfl_module_addrdie(mod, trace_addr, &mod_bias);

#if 1
			if (!cudie)
			{
				// Sadly clang does not generate the section .debug_aranges, thus
				// dwfl_module_addrdie will fail early. Clang doesn't either set
				// the lowpc/highpc/range info for every compilation unit.
				//
				// So in order to save the world:
				// for every compilation unit, we will iterate over every single
				// DIEs. Normally functions should have a lowpc/highpc/range, which
				// we will use to infer the compilation unit.

				// note that this is probably badly inefficient.
				while ((cudie = dwfl_module_nextcu(mod, cudie, &mod_bias)))
				{
					Dwarf_Die die_mem;
					Dwarf_Die *fundie = find_fundie_by_pc(cudie,
														  trace_addr - mod_bias, &die_mem);
					if (fundie)
					{
						break;
					}
				}
			}
#endif

//#define BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE
#ifdef BACKWARD_I_DO_NOT_RECOMMEND_TO_ENABLE_THIS_HORRIBLE_PIECE_OF_CODE
			if (!cudie)
			{
				// If it's still not enough, lets dive deeper in the shit, and try
				// to save the world again: for every compilation unit, we will
				// load the corresponding .debug_line section, and see if we can
				// find our address in it.

				Dwarf_Addr cfi_bias;
				Dwarf_CFI *cfi_cache = dwfl_module_eh_cfi(mod, &cfi_bias);

				Dwarf_Addr bias;
				while ((cudie = dwfl_module_nextcu(mod, cudie, &bias)))
				{
					if (dwarf_getsrc_die(cudie, trace_addr - bias))
					{

						// ...but if we get a match, it might be a false positive
						// because our (address - bias) might as well be valid in a
						// different compilation unit. So we throw our last card on
						// the table and lookup for the address into the .eh_frame
						// section.

						handle<Dwarf_Frame *> frame;
						dwarf_cfi_addrframe(cfi_cache, trace_addr - cfi_bias, &frame);
						if (frame)
						{
							break;
						}
					}
				}
			}
#endif

			if (!cudie)
			{
				return trace; // this time we lost the game :/
			}

			// Now that we have a compilation unit DIE, this function will be able
			// to load the corresponding section in .debug_line (if not already
			// loaded) and hopefully find the source location mapped to our
			// address.
			Dwarf_Line *srcloc = dwarf_getsrc_die(cudie, trace_addr - mod_bias);

			if (srcloc)
			{
				const char *srcfile = dwarf_linesrc(srcloc, 0, 0);
				if (srcfile)
				{
					trace.source.filename = srcfile;
				}
				int line = 0, col = 0;
				dwarf_lineno(srcloc, &line);
				dwarf_linecol(srcloc, &col);
				trace.source.line = line;
				trace.source.col = col;
			}

			deep_first_search_by_pc(cudie, trace_addr - mod_bias,
									inliners_search_cb(trace));
			if (trace.source.function.size() == 0)
			{
				// fallback.
				trace.source.function = trace.object_function;
			}

			return trace;
		}

	private:
		typedef details::handle<Dwfl *, details::deleter<void, Dwfl *, &dwfl_end>>
			dwfl_handle_t;
		details::handle<Dwfl_Callbacks *, details::default_delete<Dwfl_Callbacks *>>
			_dwfl_cb;
		dwfl_handle_t _dwfl_handle;
		bool _dwfl_handle_initialized;

		// defined here because in C++98, template function cannot take locally
		// defined types... grrr.
		struct inliners_search_cb
		{
			void operator()(Dwarf_Die *die)
			{
				switch (dwarf_tag(die))
				{
					const char *name;
				case DW_TAG_subprogram:
					if ((name = dwarf_diename(die)))
					{
						trace.source.function = name;
					}
					break;

				case DW_TAG_inlined_subroutine:
					ResolvedTrace::SourceLoc sloc;
					Dwarf_Attribute attr_mem;

					if ((name = dwarf_diename(die)))
					{
						sloc.function = name;
					}
					if ((name = die_call_file(die)))
					{
						sloc.filename = name;
					}

					Dwarf_Word line = 0, col = 0;
					dwarf_formudata(dwarf_attr(die, DW_AT_call_line,
											   &attr_mem),
									&line);
					dwarf_formudata(dwarf_attr(die, DW_AT_call_column,
											   &attr_mem),
									&col);
					sloc.line = line;
					sloc.col = col;

					trace.inliners.push_back(sloc);
					break;
				};
			}
			ResolvedTrace &trace;
			inliners_search_cb(ResolvedTrace &t) : trace(t) {}
		};

		static bool die_has_pc(Dwarf_Die *die, Dwarf_Addr pc)
		{
			Dwarf_Addr low, high;

			// continuous range
			if (dwarf_hasattr(die, DW_AT_low_pc) and
				dwarf_hasattr(die, DW_AT_high_pc))
			{
				if (dwarf_lowpc(die, &low) != 0)
				{
					return false;
				}
				if (dwarf_highpc(die, &high) != 0)
				{
					Dwarf_Attribute attr_mem;
					Dwarf_Attribute *attr = dwarf_attr(die, DW_AT_high_pc, &attr_mem);
					Dwarf_Word value;
					if (dwarf_formudata(attr, &value) != 0)
					{
						return false;
					}
					high = low + value;
				}
				return pc >= low && pc < high;
			}

			// non-continuous range.
			Dwarf_Addr base;
			ptrdiff_t offset = 0;
			while ((offset = dwarf_ranges(die, offset, &base, &low, &high)) > 0)
			{
				if (pc >= low && pc < high)
				{
					return true;
				}
			}
			return false;
		}

		static Dwarf_Die *find_fundie_by_pc(Dwarf_Die *parent_die, Dwarf_Addr pc,
											Dwarf_Die *result)
		{
			if (dwarf_child(parent_die, result) != 0)
			{
				return 0;
			}

			Dwarf_Die *die = result;
			do
			{
				switch (dwarf_tag(die))
				{
				case DW_TAG_subprogram:
				case DW_TAG_inlined_subroutine:
					if (die_has_pc(die, pc))
					{
						return result;
					}
				default:
					bool declaration = false;
					Dwarf_Attribute attr_mem;
					dwarf_formflag(dwarf_attr(die, DW_AT_declaration,
											  &attr_mem),
								   &declaration);
					if (!declaration)
					{
						// let's be curious and look deeper in the tree,
						// function are not necessarily at the first level, but
						// might be nested inside a namespace, structure etc.
						Dwarf_Die die_mem;
						Dwarf_Die *indie = find_fundie_by_pc(die, pc, &die_mem);
						if (indie)
						{
							*result = die_mem;
							return result;
						}
					}
				};
			} while (dwarf_siblingof(die, result) == 0);
			return 0;
		}

		template <typename CB>
		static bool deep_first_search_by_pc(Dwarf_Die *parent_die,
											Dwarf_Addr pc, CB cb)
		{
			Dwarf_Die die_mem;
			if (dwarf_child(parent_die, &die_mem) != 0)
			{
				return false;
			}

			bool branch_has_pc = false;
			Dwarf_Die *die = &die_mem;
			do
			{
				bool declaration = false;
				Dwarf_Attribute attr_mem;
				dwarf_formflag(dwarf_attr(die, DW_AT_declaration, &attr_mem), &declaration);
				if (!declaration)
				{
					// let's be curious and look deeper in the tree, function are
					// not necessarily at the first level, but might be nested
					// inside a namespace, structure, a function, an inlined
					// function etc.
					branch_has_pc = deep_first_search_by_pc(die, pc, cb);
				}
				if (!branch_has_pc)
				{
					branch_has_pc = die_has_pc(die, pc);
				}
				if (branch_has_pc)
				{
					cb(die);
				}
			} while (dwarf_siblingof(die, &die_mem) == 0);
			return branch_has_pc;
		}

		static const char *die_call_file(Dwarf_Die *die)
		{
			Dwarf_Attribute attr_mem;
			Dwarf_Sword file_idx = 0;

			dwarf_formsdata(dwarf_attr(die, DW_AT_call_file, &attr_mem),
							&file_idx);

			if (file_idx == 0)
			{
				return 0;
			}

			Dwarf_Die die_mem;
			Dwarf_Die *cudie = dwarf_diecu(die, &die_mem, 0, 0);
			if (!cudie)
			{
				return 0;
			}

			Dwarf_Files *files = 0;
			size_t nfiles;
			dwarf_getsrcfiles(cudie, &files, &nfiles);
			if (!files)
			{
				return 0;
			}

			return dwarf_filesrc(files, file_idx, 0, 0);
		}
	};
#endif // BACKWARD_HAS_DW == 1

	template <>
	class TraceResolverImpl<system_tag::linux_tag> : public TraceResolverLinuxImpl<trace_resolver_tag::current>
	{
	};

#endif // BACKWARD_SYSTEM_LINUX

	class TraceResolver : public TraceResolverImpl<system_tag::current_tag>
	{
	};

	/*************** CODE SNIPPET ***************/

	class SourceFile
	{
	public:
		typedef std::vector<std::pair<unsigned, std::string>> lines_t;

		SourceFile() {}
		SourceFile(const std::string &path) : _file(new std::ifstream(path.c_str())) {}
		bool is_open() const { return _file->is_open(); }

		lines_t &get_lines(unsigned line_start, unsigned line_count, lines_t &lines)
		{
			using namespace std;
			// This function make uses of the dumbest algo ever:
			//	1) seek(0)
			//	2) read lines one by one and discard until line_start
			//	3) read line one by one until line_start + line_count
			//
			// If you are getting snippets many time from the same file, it is
			// somewhat a waste of CPU, feel free to benchmark and propose a
			// better solution ;)

			_file->clear();
			_file->seekg(0);
			string line;
			unsigned line_idx;

			for (line_idx = 1; line_idx < line_start; ++line_idx)
			{
				std::getline(*_file, line);
				if (!*_file)
				{
					return lines;
				}
			}

			// think of it like a lambda in C++98 ;)
			// but look, I will reuse it two times!
			// What a good boy am I.
			struct isspace
			{
				bool operator()(char c)
				{
					return std::isspace(c);
				}
			};

			bool started = false;
			for (; line_idx < line_start + line_count; ++line_idx)
			{
				getline(*_file, line);
				if (!*_file)
				{
					return lines;
				}
				if (!started)
				{
					if (std::find_if(line.begin(), line.end(),
									 not_isspace()) == line.end())
						continue;
					started = true;
				}
				lines.push_back(make_pair(line_idx, line));
			}

			lines.erase(
				std::find_if(lines.rbegin(), lines.rend(),
							 not_isempty())
					.base(),
				lines.end());
			return lines;
		}

		lines_t get_lines(unsigned line_start, unsigned line_count)
		{
			lines_t lines;
			return get_lines(line_start, line_count, lines);
		}

		// there is no find_if_not in C++98, lets do something crappy to
		// workaround.
		struct not_isspace
		{
			bool operator()(char c)
			{
				return !std::isspace(c);
			}
		};
		// and define this one here because C++98 is not happy with local defined
		// struct passed to template functions, fuuuu.
		struct not_isempty
		{
			bool operator()(const lines_t::value_type &p)
			{
				return !(std::find_if(p.second.begin(), p.second.end(),
									  not_isspace()) == p.second.end());
			}
		};

		void swap(SourceFile &b)
		{
			_file.swap(b._file);
		}

#ifdef BACKWARD_ATLEAST_CXX11
		SourceFile(SourceFile &&from) : _file(0)
		{
			swap(from);
		}
		SourceFile &operator=(SourceFile &&from)
		{
			swap(from);
			return *this;
		}
#else
		explicit SourceFile(const SourceFile &from)
		{
			// some sort of poor man's move semantic.
			swap(const_cast<SourceFile &>(from));
		}
		SourceFile &operator=(const SourceFile &from)
		{
			// some sort of poor man's move semantic.
			swap(const_cast<SourceFile &>(from));
			return *this;
		}
#endif

	private:
		details::handle<std::ifstream *,
						details::default_delete<std::ifstream *>>
			_file;

#ifdef BACKWARD_ATLEAST_CXX11
		SourceFile(const SourceFile &) = delete;
		SourceFile &operator=(const SourceFile &) = delete;
#endif
	};

	class SnippetFactory
	{
	public:
		typedef SourceFile::lines_t lines_t;

		lines_t get_snippet(const std::string &filename,
							unsigned line_start, unsigned context_size)
		{

			SourceFile &src_file = get_src_file(filename);
			unsigned start = line_start - context_size / 2;
			return src_file.get_lines(start, context_size);
		}

		lines_t get_combined_snippet(
			const std::string &filename_a, unsigned line_a,
			const std::string &filename_b, unsigned line_b,
			unsigned context_size)
		{
			SourceFile &src_file_a = get_src_file(filename_a);
			SourceFile &src_file_b = get_src_file(filename_b);

			lines_t lines = src_file_a.get_lines(line_a - context_size / 4,
												 context_size / 2);
			src_file_b.get_lines(line_b - context_size / 4, context_size / 2,
								 lines);
			return lines;
		}

		lines_t get_coalesced_snippet(const std::string &filename,
									  unsigned line_a, unsigned line_b, unsigned context_size)
		{
			SourceFile &src_file = get_src_file(filename);

			using std::max;
			using std::min;
			unsigned a = min(line_a, line_b);
			unsigned b = max(line_a, line_b);

			if ((b - a) < (context_size / 3))
			{
				return src_file.get_lines((a + b - context_size + 1) / 2,
										  context_size);
			}

			lines_t lines = src_file.get_lines(a - context_size / 4,
											   context_size / 2);
			src_file.get_lines(b - context_size / 4, context_size / 2, lines);
			return lines;
		}

	private:
		typedef details::hashtable<std::string, SourceFile>::type src_files_t;
		src_files_t _src_files;

		SourceFile &get_src_file(const std::string &filename)
		{
			src_files_t::iterator it = _src_files.find(filename);
			if (it != _src_files.end())
			{
				return it->second;
			}
			SourceFile &new_src_file = _src_files[filename];
			new_src_file = SourceFile(filename);
			return new_src_file;
		}
	};

	/*************** PRINTER ***************/

#ifdef BACKWARD_SYSTEM_LINUX

	namespace Color
	{
		enum type
		{
			yellow = 33,
			purple = 35,
			reset = 39
		};
	} // namespace Color

	class Colorize
	{
	public:
		Colorize(std::FILE *os) : _os(os), _reset(false), _istty(false) {}

		void init()
		{
			_istty = isatty(fileno(_os));
		}

		void set_color(Color::type ccode)
		{
			if (!_istty)
				return;

			// I assume that the terminal can handle basic colors. Seriously I
			// don't want to deal with all the termcap shit.
			fprintf(_os, "\033[%im", static_cast<int>(ccode));
			_reset = (ccode != Color::reset);
		}

		~Colorize()
		{
			if (_reset)
			{
				set_color(Color::reset);
			}
		}

	private:
		std::FILE *_os;
		bool _reset;
		bool _istty;
	};

#else // ndef BACKWARD_SYSTEM_LINUX

	namespace Color
	{
		enum type
		{
			yellow = 0,
			purple = 0,
			reset = 0
		};
	} // namespace Color

	class Colorize
	{
	public:
		Colorize(std::FILE *) {}
		void init() {}
		void set_color(Color::type) {}
	};

#endif // BACKWARD_SYSTEM_LINUX

	class Printer
	{
	public:
		bool snippet;
		bool color;
		bool address;
		bool object;

		Printer() : snippet(true),
					color(true),
					address(false),
					object(false)
		{
		}

		template <typename ST>
		FILE *print(ST &st, FILE *os = stderr)
		{
			Colorize colorize(os);
			if (color)
			{
				colorize.init();
			}
			print_header(os, st.thread_id());
			_resolver.load_stacktrace(st);
			for (size_t trace_idx = st.size(); trace_idx > 0; --trace_idx)
			{
				print_trace(os, _resolver.resolve(st[trace_idx - 1]), colorize);
			}
			return os;
		}

		template <typename IT>
		FILE *print(IT begin, IT end, FILE *os = stderr, size_t thread_id = 0)
		{
			Colorize colorize(os);
			if (color)
			{
				colorize.init();
			}
			print_header(os, thread_id);
			for (; begin != end; ++begin)
			{
				print_trace(os, *begin, colorize);
			}
			return os;
		}

	private:
		TraceResolver _resolver;
		SnippetFactory _snippets;

		void print_header(FILE *os, unsigned thread_id)
		{
			fprintf(os, "Stack trace (most recent call last)");
			if (thread_id)
			{
				fprintf(os, " in thread %u:\n", thread_id);
			}
			else
			{
				fprintf(os, ":\n");
			}
		}

		void print_trace(FILE *os, const ResolvedTrace &trace,
						 Colorize &colorize)
		{
			fprintf(os, "#%-2u", trace.idx);
			bool already_indented = true;

			if (!trace.source.filename.size() || object)
			{
				fprintf(os, "   Object \"%s\", at %p, in %s\n",
						trace.object_filename.c_str(), trace.addr,
						trace.object_function.c_str());
				already_indented = false;
			}

			for (size_t inliner_idx = trace.inliners.size();
				 inliner_idx > 0; --inliner_idx)
			{
				if (!already_indented)
				{
					fprintf(os, "   ");
				}
				const ResolvedTrace::SourceLoc &inliner_loc = trace.inliners[inliner_idx - 1];
				print_source_loc(os, " | ", inliner_loc);
				if (snippet)
				{
					print_snippet(os, "    | ", inliner_loc,
								  colorize, Color::purple, 5);
				}
				already_indented = false;
			}

			if (trace.source.filename.size())
			{
				if (!already_indented)
				{
					fprintf(os, "   ");
				}
				print_source_loc(os, "   ", trace.source, trace.addr);
				if (snippet)
				{
					print_snippet(os, "      ", trace.source,
								  colorize, Color::yellow, 7);
				}
			}
		}

		void print_snippet(FILE *os, const char *indent,
						   const ResolvedTrace::SourceLoc &source_loc,
						   Colorize &colorize, Color::type color_code,
						   int context_size)
		{
			using namespace std;
			typedef SnippetFactory::lines_t lines_t;

			lines_t lines = _snippets.get_snippet(source_loc.filename,
												  source_loc.line, context_size);

			for (lines_t::const_iterator it = lines.begin();
				 it != lines.end(); ++it)
			{
				if (it->first == source_loc.line)
				{
					colorize.set_color(color_code);
					fprintf(os, "%s>", indent);
				}
				else
				{
					fprintf(os, "%s ", indent);
				}
				fprintf(os, "%4u: %s\n", it->first, it->second.c_str());
				if (it->first == source_loc.line)
				{
					colorize.set_color(Color::reset);
				}
			}
		}

		void print_source_loc(FILE *os, const char *indent,
							  const ResolvedTrace::SourceLoc &source_loc,
							  void *addr = 0)
		{
			fprintf(os, "%sSource \"%s\", line %i, in %s",
					indent, source_loc.filename.c_str(), (int)source_loc.line,
					source_loc.function.c_str());

			if (address && addr != 0)
			{
				fprintf(os, " [%p]\n", addr);
			}
			else
			{
				fprintf(os, "\n");
			}
		}
	};

	/*************** SIGNALS HANDLING ***************/

#ifdef BACKWARD_SYSTEM_LINUX

	class SignalHandling
	{
	public:
		static std::vector<int> make_default_signals()
		{
			const int posix_signals[] = {
				// default action: Core
				SIGILL,
				SIGABRT,
				SIGFPE,
				SIGSEGV,
				SIGBUS,
				// I am not sure the following signals should be enabled by
				// default:
				// default action: Term
				SIGHUP,
				SIGINT,
				SIGPIPE,
				SIGALRM,
				SIGTERM,
				SIGUSR1,
				SIGUSR2,
				SIGPOLL,
				SIGPROF,
				SIGVTALRM,
				SIGIO,
				SIGPWR,
				// default action: Core
				SIGQUIT,
				SIGSYS,
				SIGTRAP,
				SIGXCPU,
				SIGXFSZ};
			return std::vector<int>(posix_signals, posix_signals + sizeof posix_signals / sizeof posix_signals[0]);
		}

		SignalHandling(const std::vector<int> &posix_signals = make_default_signals()) : _loaded(false)
		{
			bool success = true;

			const size_t stack_size = 1024 * 1024 * 8;
			_stack_content.reset((char *)malloc(stack_size));
			if (_stack_content)
			{
				stack_t ss;
				ss.ss_sp = _stack_content.get();
				ss.ss_size = stack_size;
				ss.ss_flags = 0;
				if (sigaltstack(&ss, 0) < 0)
				{
					success = false;
				}
			}
			else
			{
				success = false;
			}

			for (size_t i = 0; i < posix_signals.size(); ++i)
			{
				struct sigaction action;
				memset(&action, 0, sizeof action);
				action.sa_flags = (SA_SIGINFO | SA_ONSTACK | SA_NODEFER |
								   SA_RESETHAND);
				sigfillset(&action.sa_mask);
				sigdelset(&action.sa_mask, posix_signals[i]);
				action.sa_sigaction = &sig_handler;

				int r = sigaction(posix_signals[i], &action, 0);
				if (r < 0)
					success = false;
			}

			_loaded = success;
		}

		bool loaded() const { return _loaded; }

	private:
		details::handle<char *> _stack_content;
		bool _loaded;

		static void sig_handler(int, siginfo_t *info, void *_ctx)
		{
			ucontext_t *uctx = (ucontext_t *)_ctx;

			StackTrace st;
			void *error_addr = 0;
#ifdef REG_RIP // x86_64
			error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_RIP]);
#elif defined(REG_EIP) // x86_32
			error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.gregs[REG_EIP]);
#elif defined(__arm__)
			error_addr = reinterpret_cast<void *>(uctx->uc_mcontext.arm_pc);
#else
#warning ":/ sorry, ain't know no nothing none not of your architecture!"
#endif
			if (error_addr)
			{
				st.load_from(error_addr, 32);
			}
			else
			{
				st.load_here(32);
			}

			Printer printer;
			printer.address = true;
			printer.print(st, stderr);

#if _XOPEN_SOURCE >= 700 || _POSIX_C_SOURCE >= 200809L
			psiginfo(info, 0);
#endif

			// try to forward the signal.
			raise(info->si_signo);

			// terminate the process immediately.
			puts("watf? exit");
			_exit(EXIT_FAILURE);
		}
	};

#endif // BACKWARD_SYSTEM_LINUX

#ifdef BACKWARD_SYSTEM_UNKNOWN

	class SignalHandling
	{
	public:
		SignalHandling(const std::vector<int> & = std::vector<int>()) {}
		bool init() { return false; }
		bool loaded() { return false; }
	};

#endif // BACKWARD_SYSTEM_UNKNOWN

} // namespace backward

#endif /* H_GUARD */
